#include <test/nodestore/TestBase.h>
#include <test/unit_test/SuiteJournal.h>

#include <xrpl/basics/BasicConfig.h>
#include <xrpl/basics/ByteUtilities.h>
#include <xrpl/beast/utility/temp_dir.h>
#include <xrpl/nodestore/DummyScheduler.h>
#include <xrpl/nodestore/Manager.h>

#include <memory>
#include <sstream>

namespace ripple {
namespace NodeStore {

class NuDBFactory_test : public TestBase
{
private:
    // Helper function to create a Section with specified parameters
    Section
    createSection(std::string const& path, std::string const& blockSize = "")
    {
        Section params;
        params.set("type", "nudb");
        params.set("path", path);
        if (!blockSize.empty())
            params.set("nudb_block_size", blockSize);
        return params;
    }

    // Helper function to create a backend and test basic functionality
    bool
    testBackendFunctionality(
        Section const& params,
        std::size_t expectedBlocksize)
    {
        try
        {
            DummyScheduler scheduler;
            test::SuiteJournal journal("NuDBFactory_test", *this);

            auto backend = Manager::instance().make_Backend(
                params, megabytes(4), scheduler, journal);

            if (!BEAST_EXPECT(backend))
                return false;

            if (!BEAST_EXPECT(backend->getBlockSize() == expectedBlocksize))
                return false;

            backend->open();

            if (!BEAST_EXPECT(backend->isOpen()))
                return false;

            // Test basic store/fetch functionality
            auto batch = createPredictableBatch(10, 12345);
            storeBatch(*backend, batch);

            Batch copy;
            fetchCopyOfBatch(*backend, &copy, batch);

            backend->close();

            return areBatchesEqual(batch, copy);
        }
        catch (...)
        {
            return false;
        }
    }

    // Helper function to test log messages
    void
    testLogMessage(
        Section const& params,
        beast::severities::Severity level,
        std::string const& expectedMessage)
    {
        test::StreamSink sink(level);
        beast::Journal journal(sink);

        DummyScheduler scheduler;
        auto backend = Manager::instance().make_Backend(
            params, megabytes(4), scheduler, journal);

        std::string logOutput = sink.messages().str();
        BEAST_EXPECT(logOutput.find(expectedMessage) != std::string::npos);
    }

    // Helper function to test power of two validation
    void
    testPowerOfTwoValidation(std::string const& size, bool shouldWork)
    {
        beast::temp_dir tempDir;
        auto params = createSection(tempDir.path(), size);

        test::StreamSink sink(beast::severities::kWarning);
        beast::Journal journal(sink);

        DummyScheduler scheduler;
        auto backend = Manager::instance().make_Backend(
            params, megabytes(4), scheduler, journal);

        std::string logOutput = sink.messages().str();
        bool hasWarning =
            logOutput.find("Invalid nudb_block_size") != std::string::npos;

        BEAST_EXPECT(hasWarning == !shouldWork);
    }

public:
    void
    testDefaultBlockSize()
    {
        testcase("Default block size (no nudb_block_size specified)");

        beast::temp_dir tempDir;
        auto params = createSection(tempDir.path());

        // Should work with default 4096 block size
        BEAST_EXPECT(testBackendFunctionality(params, 4096));
    }

    void
    testValidBlockSizes()
    {
        testcase("Valid block sizes");

        std::vector<std::size_t> validSizes = {4096, 8192, 16384, 32768};

        for (auto const& size : validSizes)
        {
            beast::temp_dir tempDir;
            auto params = createSection(tempDir.path(), to_string(size));

            BEAST_EXPECT(testBackendFunctionality(params, size));
        }
        // Empty value is ignored by the config parser, so uses the
        // default
        beast::temp_dir tempDir;
        auto params = createSection(tempDir.path(), "");

        BEAST_EXPECT(testBackendFunctionality(params, 4096));
    }

    void
    testInvalidBlockSizes()
    {
        testcase("Invalid block sizes");

        std::vector<std::string> invalidSizes = {
            "2048",    // Too small
            "1024",    // Too small
            "65536",   // Too large
            "131072",  // Too large
            "5000",    // Not power of 2
            "6000",    // Not power of 2
            "10000",   // Not power of 2
            "0",       // Zero
            "-1",      // Negative
            "abc",     // Non-numeric
            "4k",      // Invalid format
            "4096.5"   // Decimal
        };

        for (auto const& size : invalidSizes)
        {
            beast::temp_dir tempDir;
            auto params = createSection(tempDir.path(), size);

            // Fails
            BEAST_EXPECT(!testBackendFunctionality(params, 4096));
        }

        // Test whitespace cases separately since lexical_cast may handle them
        std::vector<std::string> whitespaceInvalidSizes = {
            "4096 ",  // Trailing space - might be handled by lexical_cast
            " 4096"   // Leading space - might be handled by lexical_cast
        };

        for (auto const& size : whitespaceInvalidSizes)
        {
            beast::temp_dir tempDir;
            auto params = createSection(tempDir.path(), size);

            // Fails
            BEAST_EXPECT(!testBackendFunctionality(params, 4096));
        }
    }

    void
    testLogMessages()
    {
        testcase("Log message verification");

        // Test valid custom block size logging
        {
            beast::temp_dir tempDir;
            auto params = createSection(tempDir.path(), "8192");

            testLogMessage(
                params,
                beast::severities::kInfo,
                "Using custom NuDB block size: 8192");
        }

        // Test invalid block size failure
        {
            beast::temp_dir tempDir;
            auto params = createSection(tempDir.path(), "5000");

            test::StreamSink sink(beast::severities::kWarning);
            beast::Journal journal(sink);

            DummyScheduler scheduler;
            try
            {
                auto backend = Manager::instance().make_Backend(
                    params, megabytes(4), scheduler, journal);
                fail();
            }
            catch (std::exception const& e)
            {
                std::string logOutput{e.what()};
                BEAST_EXPECT(
                    logOutput.find("Invalid nudb_block_size: 5000") !=
                    std::string::npos);
                BEAST_EXPECT(
                    logOutput.find(
                        "Must be power of 2 between 4096 and 32768") !=
                    std::string::npos);
            }
        }

        // Test non-numeric value failure
        {
            beast::temp_dir tempDir;
            auto params = createSection(tempDir.path(), "invalid");

            test::StreamSink sink(beast::severities::kWarning);
            beast::Journal journal(sink);

            DummyScheduler scheduler;
            try
            {
                auto backend = Manager::instance().make_Backend(
                    params, megabytes(4), scheduler, journal);

                fail();
            }
            catch (std::exception const& e)
            {
                std::string logOutput{e.what()};
                BEAST_EXPECT(
                    logOutput.find("Invalid nudb_block_size value: invalid") !=
                    std::string::npos);
            }
        }
    }

    void
    testPowerOfTwoValidation()
    {
        testcase("Power of 2 validation logic");

        // Test edge cases around valid range
        std::vector<std::pair<std::string, bool>> testCases = {
            {"4095", false},   // Just below minimum
            {"4096", true},    // Minimum valid
            {"4097", false},   // Just above minimum, not power of 2
            {"8192", true},    // Valid power of 2
            {"8193", false},   // Just above valid power of 2
            {"16384", true},   // Valid power of 2
            {"32768", true},   // Maximum valid
            {"32769", false},  // Just above maximum
            {"65536", false}   // Power of 2 but too large
        };

        for (auto const& [size, shouldWork] : testCases)
        {
            beast::temp_dir tempDir;
            auto params = createSection(tempDir.path(), size);

            // We test the validation logic by catching exceptions for invalid
            // values
            test::StreamSink sink(beast::severities::kWarning);
            beast::Journal journal(sink);

            DummyScheduler scheduler;
            try
            {
                auto backend = Manager::instance().make_Backend(
                    params, megabytes(4), scheduler, journal);
                BEAST_EXPECT(shouldWork);
            }
            catch (std::exception const& e)
            {
                std::string logOutput{e.what()};
                BEAST_EXPECT(
                    logOutput.find("Invalid nudb_block_size") !=
                    std::string::npos);
            }
        }
    }

    void
    testBothConstructorVariants()
    {
        testcase("Both constructor variants work with custom block size");

        beast::temp_dir tempDir;
        auto params = createSection(tempDir.path(), "16384");

        DummyScheduler scheduler;
        test::SuiteJournal journal("NuDBFactory_test", *this);

        // Test first constructor (without nudb::context)
        {
            auto backend1 = Manager::instance().make_Backend(
                params, megabytes(4), scheduler, journal);
            BEAST_EXPECT(backend1 != nullptr);
            BEAST_EXPECT(testBackendFunctionality(params, 16384));
        }

        // Test second constructor (with nudb::context)
        // Note: This would require access to nudb::context, which might not be
        // easily testable without more complex setup. For now, we test that
        // the factory can create backends with the first constructor.
    }

    void
    testConfigurationParsing()
    {
        testcase("Configuration parsing edge cases");

        // Test that whitespace is handled correctly
        std::vector<std::string> validFormats = {
            "8192"  // Basic valid format
        };

        // Test whitespace handling separately since lexical_cast behavior may
        // vary
        std::vector<std::string> whitespaceFormats = {
            " 8192",  // Leading space - may or may not be handled by
                      // lexical_cast
            "8192 "   // Trailing space - may or may not be handled by
                      // lexical_cast
        };

        // Test basic valid format
        for (auto const& format : validFormats)
        {
            beast::temp_dir tempDir;
            auto params = createSection(tempDir.path(), format);

            test::StreamSink sink(beast::severities::kInfo);
            beast::Journal journal(sink);

            DummyScheduler scheduler;
            auto backend = Manager::instance().make_Backend(
                params, megabytes(4), scheduler, journal);

            // Should log success message for valid values
            std::string logOutput = sink.messages().str();
            bool hasSuccessMessage =
                logOutput.find("Using custom NuDB block size") !=
                std::string::npos;
            BEAST_EXPECT(hasSuccessMessage);
        }

        // Test whitespace formats - these should work if lexical_cast handles
        // them
        for (auto const& format : whitespaceFormats)
        {
            beast::temp_dir tempDir;
            auto params = createSection(tempDir.path(), format);

            // Use a lower threshold to capture both info and warning messages
            test::StreamSink sink(beast::severities::kDebug);
            beast::Journal journal(sink);

            DummyScheduler scheduler;
            try
            {
                auto backend = Manager::instance().make_Backend(
                    params, megabytes(4), scheduler, journal);
                fail();
            }
            catch (...)
            {
                // Fails
                BEAST_EXPECT(!testBackendFunctionality(params, 8192));
            }
        }
    }

    void
    testDataPersistence()
    {
        testcase("Data persistence with different block sizes");

        std::vector<std::string> blockSizes = {
            "4096", "8192", "16384", "32768"};

        for (auto const& size : blockSizes)
        {
            beast::temp_dir tempDir;
            auto params = createSection(tempDir.path(), size);

            DummyScheduler scheduler;
            test::SuiteJournal journal("NuDBFactory_test", *this);

            // Create test data
            auto batch = createPredictableBatch(50, 54321);

            // Store data
            {
                auto backend = Manager::instance().make_Backend(
                    params, megabytes(4), scheduler, journal);
                backend->open();
                storeBatch(*backend, batch);
                backend->close();
            }

            // Retrieve data in new backend instance
            {
                auto backend = Manager::instance().make_Backend(
                    params, megabytes(4), scheduler, journal);
                backend->open();

                Batch copy;
                fetchCopyOfBatch(*backend, &copy, batch);

                BEAST_EXPECT(areBatchesEqual(batch, copy));
                backend->close();
            }
        }
    }

    void
    run() override
    {
        testDefaultBlockSize();
        testValidBlockSizes();
        testInvalidBlockSizes();
        testLogMessages();
        testPowerOfTwoValidation();
        testBothConstructorVariants();
        testConfigurationParsing();
        testDataPersistence();
    }
};

BEAST_DEFINE_TESTSUITE(NuDBFactory, ripple_core, ripple);

}  // namespace NodeStore
}  // namespace ripple
